home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 348_01 / z80a.c < prev    next >
Text File  |  1991-04-30  |  23KB  |  961 lines
  1. /*
  2.  
  3. This file contains the main program and line assembly routines for the
  4. assembler.  The main program parses the command line, feeds the source lines
  5. to the line assembly routine, and sends the results to the listing and object
  6. file output routines.  It also coordinates the activities of everything.  The
  7. line assembly routine uses the expression analyzer and the lexical analyzer to
  8. parse the source line convert it into the object bytes that it represents.
  9. */
  10.  
  11. #define YES 1
  12. #define NO  0
  13.  
  14. /*  Get global goodies:  */
  15.  
  16. #include "z80a.h"
  17.  
  18. /*  Define global mailboxes for all modules:                */
  19.  
  20. char errcode, line[MAXLINE + 1], title[MAXLINE], sub_tit[MAXLINE];
  21. int pass = 0;
  22. int code = TRUE;
  23. int listok = TRUE;
  24. int eject, filesp, forwd, listhex;
  25. unsigned address, bytes, errors, listleft, obj[MAXLINE], pc;
  26. unsigned pagelen = 60;
  27. FILE *filestk[FILES], *source;
  28. TOKEN token;
  29.  
  30. /*  Mainline routine.  This routine parses the command line, sets up    */
  31. /*  the assembler at the beginning of each pass, feeds the source text    */
  32. /*  to the line assembler, feeds the result to the listing and hex file    */
  33. /*  drivers, and cleans everything up at the end of the run.        */
  34.  
  35. static int done, ifsp, off;
  36.  
  37. main(argc,argv)
  38. int argc;
  39. char **argv;
  40. {
  41.     SCRATCH unsigned *o;
  42.     int newline();
  43.     void asm_line();
  44.     void lclose(), lopen(), lputs();
  45.     void hclose(), hopen(), hputc();
  46.     void error_s(), fatal_error(), warning();
  47.  
  48.     printf("Z80 Cross-Assembler (Portable Z80ASM version) Ver 0.0\n");
  49.     printf("Copyright (c) 1988 Michael G. Panas\n\n");
  50.  
  51.     while (--argc) {
  52.     if (**++argv == '-') {
  53.         switch (toupper(*++*argv)) {
  54.         case 'L':   if (!*++*argv) {
  55.                 if (!--argc) { warning(NOLST);  break; }
  56.                 else ++argv;
  57.                 }
  58.                 lopen(*argv);
  59.                 break;
  60.  
  61.         case 'O':   if (!*++*argv) {
  62.                 if (!--argc) { warning(NOHEX);  break; }
  63.                 else ++argv;
  64.                 }
  65.                 hopen(*argv);
  66.                 break;
  67.  
  68.         default:    warning(BADOPT);
  69.         }
  70.     }
  71.     else if (filestk[0]) warning(TWOASM);
  72.     else if (!(filestk[0] = fopen(*argv,"r"))) fatal_error(ASMOPEN);
  73.     }
  74.     if (!filestk[0]) fatal_error(NOASM);
  75.  
  76.     while (++pass < 3) {
  77.     fseek(source = filestk[0],0L,0);  done = off = FALSE;
  78.     errors = filesp = ifsp = pc = 0;  title[0] = '\0';
  79.     while (!done) {
  80.         errcode = ' ';
  81.         if (newline()) {
  82.         error_s('*');
  83.         strcpy(line,"\tEND\n");
  84.         done = eject = TRUE;  listhex = FALSE;
  85.         bytes = 0;
  86.         }
  87.         else asm_line();
  88.         pc = word(pc + bytes);
  89.         if (pass == 2) {
  90.         lputs();
  91.         for (o = obj; bytes--; hputc(*o++));
  92.         }
  93.     }
  94.     }
  95.  
  96.     fclose(filestk[0]);  lclose();  hclose();
  97.  
  98.     if (errors) printf("%d Error(s)\n",errors);
  99.     else printf("No Errors\n");
  100.  
  101.     exit(errors);
  102. }
  103.  
  104. /*  Line assembly routine.  This routine gets expressions and tokens    */
  105. /*  from the source file using the expression evaluator and lexical    */
  106. /*  analyzer, respectively.  It fills a buffer with the machine code    */
  107. /*  bytes and returns nothing.                        */
  108.  
  109. static char label[MAXLINE];
  110. static int ifstack[IFDEPTH] = { ON };
  111.  
  112. static OPCODE *opcod;
  113.  
  114. void asm_line()
  115. {
  116.     SCRATCH int i;
  117.     int isalph(), popc();
  118.     OPCODE *find_code(), *find_operator();
  119.     void do_label(), flush(), normal_op(), pseudo_op();
  120.     void error_s(), pops(), pushc(), trash(), trash_lex();
  121. #ifdef MICROSOFT_C
  122.     void put_len(unsigned);
  123. #else
  124.     void put_len();
  125. #endif
  126.  
  127.     address = pc;  bytes = 0;  eject = forwd = listhex = FALSE;
  128.     for (i = 0; i < BIGINST; obj[i++] = NOP);
  129.  
  130.     label[0] = '\0';
  131.  
  132.     if ((i = popc()) != ' ' && i != '\n') {
  133.     if (isalph(i)) {
  134.         pushc(i);  pops(label);
  135.         if (find_operator(label)) { label[0] = '\0';  error_s('L'); }
  136.     }
  137.     else {
  138.         error_s('L');
  139.         while ((i = popc()) != ' ' && i != '\n');
  140.     }
  141.     }
  142.  
  143.     trash(); opcod = NULL;
  144.     if ((i = popc()) != '\n') {
  145.     if (!isalph(i)) error_s('S');
  146.     else {
  147.         pushc(i);  pops(token.sval);
  148.         if (!(opcod = find_code(token.sval))) error_s('O');
  149.     }
  150.     if (!opcod) { listhex = TRUE;  bytes = BIGINST; }
  151.     }
  152.  
  153.     if (opcod && opcod -> attr & ISIF) { if (label[0]) error_s('L'); }
  154.     else if (off) { listhex = FALSE;  flush();  return; }
  155.  
  156.     if (!opcod) { do_label();  flush(); }
  157.     else {
  158.     listhex = TRUE;
  159.     trash_lex();        /* space allowed here - don't eat '*' */
  160.     if (opcod -> attr & PSEUDO) {
  161.         pseudo_op();
  162.         if (bytes) put_len(bytes);
  163.     } else {
  164.         normal_op();
  165.         put_len(0);
  166.     }
  167.     flush(); /* throw rest of line away */
  168.     }
  169.     source = filestk[filesp];
  170.     return;
  171. }
  172.  
  173. static void flush()
  174. {
  175.     while (popc() != '\n');
  176. }
  177.  
  178. static void do_label()
  179. {
  180.     SCRATCH SYMBOL *l;
  181.     unsigned pin, st;
  182.     SYMBOL *find_symbol(), *new_symbol();
  183.     void error_s();
  184.  
  185.     if (label[0]) {
  186.     listhex = TRUE;
  187.     if (label[0] == '@') {
  188.         pin = PIN;
  189.         st = 1;
  190.     } else {
  191.         pin = st = 0;
  192.     }
  193.     if (pass == 1) {
  194.         if (!((l = new_symbol(&label[st])) -> attr)) {
  195.         l -> attr = FORWD + VAL + pin;
  196.         l -> valu = pc;
  197.         l -> len = 2; /* preset length */
  198.         }
  199.     }
  200.     else {
  201.         if (l = find_symbol(&label[st])) {
  202.         l -> attr = VAL + pin;
  203.         if (l -> valu != pc) error_s('M');
  204.         }
  205.         else error_s('P');
  206.     }
  207.     }
  208. }
  209.  
  210. static void put_len(length)
  211. unsigned length;
  212. {
  213.     unsigned st = 0;
  214.     SCRATCH SYMBOL *l;
  215.     SYMBOL *find_symbol();
  216.     
  217.     if (label[0]) {
  218.     if (label[0] == '@')    st = 1;
  219.     if (l = find_symbol(&label[st])) {
  220.         l -> len = length;
  221.     }
  222.     }
  223. }
  224. static void put_attr(attrv)
  225. unsigned attrv;
  226. {
  227.     unsigned st = 0;
  228.     SCRATCH SYMBOL *l;
  229.     SYMBOL *find_symbol();
  230.     
  231.     if (label[0]) {
  232.     if (label[0] == '@')    st = 1;
  233.     if (l = find_symbol(&label[st])) {
  234.         l -> attr |= attrv;
  235.     }
  236.     }
  237. }
  238.  
  239. unsigned get_len(sym)
  240. char *sym;
  241. {
  242.     SCRATCH SYMBOL *l;
  243.     SYMBOL *find_symbol();
  244.     
  245.     if (pass == 1) return 1;
  246.     if (l = find_symbol(sym)) {
  247.         if (l -> len == 0) return 2;
  248.         return l -> len;
  249.     }
  250.     return 0;
  251. }
  252.  
  253. static void normal_op()
  254. {
  255.     SCRATCH unsigned t, opcode, op, left, index, long_op;
  256.     int grab_comma();
  257.     unsigned expr(), grab_index();
  258.     TOKEN *lex(), *lex_op();
  259.     void do_label(), error_s(), s_error(), unlex();
  260.  
  261.     opcode = opcod -> valu;
  262.     do_label();
  263.     left = ((opcod -> attr & SHIFT) >> 8);
  264.     long_op = NO;
  265.     
  266.     switch (opcod -> attr & OPTYPE) {
  267.     case NO_ARG:
  268.             bytes = 1;
  269.             break;
  270.  
  271.     case NO_ARG_L:    long_op = YES;
  272.             bytes = 2;
  273.             break;
  274.  
  275.     case ONE_ARG:    /* all 8 bit IMM mode instuctions */
  276.             if (left) { /* LDI case */
  277.                 op = (lex() -> valu);
  278.                 switch (token.attr & TYPE) {
  279.                     case MIX:
  280.                     case REG: break;
  281.                     default:  goto error;
  282.                 }
  283.                 if (token.attr & INDEX) { /* IX or IY */
  284.                     opcode += ((op << 8)+0x30); /* set prefix */
  285.                     if (grab_comma()) goto error;
  286.                     op = grab_index();
  287.                 /* SEP eaten by grab_index() */
  288.                     op += (expr() & 0xff) << 8;
  289.                     long_op = YES;
  290.                     bytes = 4;
  291.                     break;
  292.                 }
  293.                 if (grab_sep()) goto error; /* no semicolon */
  294.                 opcode += (op << left);
  295.             }
  296.             op = expr();
  297.             bytes = 2;
  298.             break;
  299.  
  300.     case ONE_ARG_L: /* opcode is one or two bytes with arg */
  301.             /* JUMPI and LDSP only */
  302.             op = lex() -> valu;
  303.             if ((token.attr & TYPE) != REG) {
  304.                 goto error;
  305.             }
  306.             if (token.attr & INDEX) { /* IX or IY */
  307.                 opcode += (op << 8); /* set prefix */
  308.                 long_op = YES;
  309.                 bytes = 2;
  310.                 break;
  311.             }
  312.             if (op != HL) goto error; /* only HL allowed */
  313.             bytes = 1;
  314.             break;
  315.     
  316.     case ONE_ARG_L2: /* opcode is two bytes with arg type 2 */
  317.             /* ADCHL, ADDIY, ADDIX, SBCHL only */
  318.             op = lex() -> valu;
  319.             if ((token.attr & TYPE) != REG) {
  320.                 goto error;
  321.             }
  322.             switch (op) {
  323.                 case BC: op = 0; break;
  324.                 case DE: op = 1; break;
  325.                 case X: op = 2;
  326.                     if (opcode != 0xdd09) goto error;
  327.                     break;
  328.                 case Y: op = 2;
  329.                     if (opcode != 0xfd09) goto error;
  330.                     break;
  331.                 case HL: op = 2;
  332.                     if (opcode == 0xdd09 || opcode == 0xfd09)
  333.                         goto error;
  334.                     break;
  335.                 case SP: op = 3; break;
  336.                 default: goto error;
  337.             }
  338.             opcode += (op << 4);
  339.             long_op = YES;
  340.             bytes = 2;
  341.             break;            
  342.  
  343.     case CALL:
  344.     case